Computing devices which allow a user to enter data with a stylus are becoming more and more popular. This type of computing device, which includes personal digital assistants and tablet personal computers, often allow a user to enter data by writing on a surface with a stylus to create electronic ink. The user moves the pen or stylus over a digitizing surface, and an underlying ink-enabled software platform converts the physical movement of the pen into ink strokes and eventually into groupings of handwritten words or drawings. Electronic ink is particularly convenient for users who cannot type quickly with a keyboard, or when the use of a keyboard is impractical.
While ink-enabled platforms and corresponding ink-aware software applications and controls are becoming more common, it is difficult to efficiently test these platforms and such ink-aware applications and controls. “Writing” electronic ink is an inherently manual process, and the features of electronic ink are highly dependent on the individual writing the ink. Because no two users have the same handwriting, no two users running the exact same test can expect the same response from a platform, application or control. This discrepancy is particularly true for applications that recognize text using handwriting recognition.
For example, a software developer may want to test how well a text input panel or “TIP” (i.e., a stand-alone user interface for receiving electronic ink, converting the electronic ink into typewritten text and then inserting the text into a target application) operates with an application. In order to test the text input panel, the developer would need to (1) launch the application, (2) launch the text input panel, (3) switch to a control that will accept input from a stylus, (4) write the desired text electronic ink, (5) activate a command to recognize and insert the text into the application, and (6) verify that the proper typewritten text was accurately inserted into the application.
Each of steps (1)-(3) and (5)-(6) are straightforward, and testing automation processes are well known to execute each of these steps. Step (4), however, can be time consuming if manually performed, especially if the software developer wishes to execute multiple (e.g., more than 1,000) tests with multiple runs of the test pass. Further, if the tester wished to run different variations of the same test, such as, for example, writing the electronic ink at a 45° angle, writing the electronic ink smaller or larger, or writing the electronic more quickly or more slowly, then the user would need to repeat step (4) even more often.
In order to make the testing of ink enabled platforms and ink-aware applications and controls more efficient and reproducible, it would be desirable to automate the process of creating electronic ink. In this manner, the same electronic ink can be created for testing again and again. One such technique for consistently recreating electronic ink is to mount the pen or stylus on an electromechanical device, and then control the device to mimic the user's actions. While this approach will consistently recreate electronic ink, it is relatively slow, difficult to employ, and resource intensive.
Another technique that can be employed is to introduce electronic ink data directly into the platform, application or control being tested. Software developers conventionally implement this technique by placing automation hooks in the specific layers of the software system to be tested. With this approach, however, the electronic ink data must be submitted in the particular format expected at that layer of the system. This can be difficult to implement, and the data format is specific to the layer at which it is used. That is, the data cannot later be employed to test a software platform, application, or control through a different system layer. Accordingly, it would be beneficial to allow a variety of software platforms, applications or controls to be tested using data that can easily and consistently be reproduced.